home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 013 / hdutil.arc / MARK.ASM < prev    next >
Assembly Source File  |  1986-08-25  |  14KB  |  346 lines
  1. PAGE ,132
  2. TITLE IBM-PC Mark/UnMark-Bad-Cluster Program, Version 2.20, 25-Aug-1986
  3.  
  4. ;
  5. ; Written By Steven Georgiades
  6. ;
  7. ; IBM-PC/XT Mark/UnMark-Bad-Cluster Program
  8. ;   This program will allow you to mark or unmark a cluster on your disk as
  9. ;   bad.  It should work under all versions of DOS 2.00 and higher, and should
  10. ;   work on the PC, XT, AT, PCJr. and all compatibles.  The programs is invoked
  11. ;   as follows:
  12. ;
  13. ;         MARK [d:] [/U | /M] n [[d:] [/U | /M] n [[...]]]
  14. ;
  15. ;           d:   Optional drive letter.  If this is omitted, the default
  16. ;                drive is used.  
  17. ;
  18. ;           /U   Un-mark switch.  The following clusters will be un-marked.
  19. ;                If no switch is specified, Un-mark is assumed.
  20. ;
  21. ;           /M   Mark switch.  The following clusters will be marked bad.
  22. ;
  23. ;           n    Cluster Number, in decimal.  The first data cluster is 2.
  24. ;                (Don't blame me.  DOS defines it that way.)
  25. ; 
  26. ;
  27. ;       If you are using this program and find it of value, your
  28. ;       contribution in any amount ($10.00 suggested) will be greatly
  29. ;       appreciated.  Makes checks payable to Steven M. Georgiades.
  30. ;               Thank you.
  31. ;
  32. ;       If you have any questions or comments about this or any other
  33. ;       SMG program, write to me at the following address:
  34. ;
  35. ;               Steven M. Georgiades
  36. ;               701-H South Hayward Street
  37. ;               Anaheim, CA 92804
  38. ;
  39.  
  40. CODE      SEGMENT BYTE PUBLIC 'CODE'
  41.  
  42.           ASSUME  CS:CODE,DS:CODE,ES:CODE,SS:CODE
  43.  
  44.           ORG     80H
  45.  
  46. PARAM     LABEL   BYTE
  47.  
  48.           ORG     100H
  49.  
  50. MARK:     JMP     BEGIN
  51.  
  52. DIGIT     DB      "0123456789ABCDEF"
  53. SIGNON    DB      "Mark, Version 2.20",13,10,10,"$"
  54.  
  55. CLSTMSG   DB      "Cluster XXXXX$"
  56. INVALID   DB      " does not exist!",7,13,10,"$"
  57.  
  58. BADMSG    DB      " is already marked as bad",13,10,"$"
  59. INUSEMSG  DB      " is currently in use by a file",13,10,"$"
  60. RESVMSG   DB      " is reserved",13,10,"$"
  61.  
  62. NOTBAD    DB      " is not marked as bad",13,10,"$"
  63.  
  64. MARKMSG   DB      " has been marked as bad",13,10,"$"
  65. UNMRKMSG  DB      " has been un-marked as bad",13,10,"$"
  66.  
  67. CLSTSEC   DW      ?
  68. CLSTTOT   DW      ?
  69. CLUST     DW      ?
  70. DRIVE     DB      ?
  71. EOF       DW      ?
  72. FATSEC    DW      ?
  73. FATSIZE   DB      ?
  74. FLAG      DB      0
  75. OLDDRV    DB      -1
  76. SECSIZE   DW      ?
  77.  
  78. BEGIN:    MOV     AH,9                          ; Output Sign-On Message
  79.           MOV     DX,OFFSET SIGNON
  80.           INT     21H
  81.           MOV     AH,19H                        ; Get Default Drive Number
  82.           INT     21H
  83.           MOV     DRIVE,AL                      ;   and Save
  84.           MOV     SI,OFFSET PARAM               ; Set up Pointer to Parameter
  85.           LODSB                                 ; Read Parameter Length
  86.           CBW
  87.           MOV     BX,AX
  88.           MOV     BYTE PTR [SI][BX],0           ; Terminate Parameter String
  89. STRIP:    LODSB                                 ; Strip Off Leading Whitespace
  90.           CMP     AL,' '
  91.           JE      STRIP
  92.           CMP     AL,9
  93.           JE      STRIP
  94.           OR      AL,AL                         ; If End-of-Parameter List,
  95.           JNZ     NOTDONE
  96.           MOV     AX,4C00H                      ;   Exit to DOS
  97.           INT     21H
  98. NOTDONE:  CMP     AL,'/'                        ; If Switch, Process
  99.           JNE     NOSWITCH
  100.           LODSB                                 ; Get Switch Letter
  101.           AND     AL,0DFH                       ; Convert to Upper Case
  102.           CMP     AL,'U'                        ; If '/U', Reset MARK Flag
  103.           JE      SWITCHU
  104.           CMP     AL,'M'                        ; If Not '/M', Next Character
  105.           JNE     STRIP
  106.           MOV     FLAG,-1                       ; Else Set MARK Flag
  107.           JMP     SHORT STRIP
  108. SWITCHU:  MOV     FLAG,0                        ; Reset MARK Flag
  109.           JMP     SHORT STRIP
  110. NOSWITCH: LODSB                                 ; Get Drive Letter
  111.           CMP     AL,':'
  112.           JNE     NODRIVE
  113.           INC     SI
  114.           AND     AL,0DFH                       ; Convert to Upper Case
  115.           SUB     AL,'A'                        ; Convert to Drive Number 
  116.           MOV     DRIVE,AL                      ; Save Drive Number
  117.           JMP     STRIP                         ; Get Next Paramter
  118. NODRIVE:  SUB     SI,2                          ; ReUse Last Character
  119.           CALL    GET_WORD                      ; Read Cluster Number (Hex)
  120.           MOV     CLUST,DX                      ; Save Cluster Number
  121.           MOV     AL,DRIVE                      ; If Different Drive,
  122.           CMP     AL,OLDDRV
  123.           JE      DRV_OK
  124.           PUSH    SI                            ;   Save Parameter Pointer
  125.           MOV     OLDDRV,AL                     ;   Save New Drive
  126.           MOV     BX,OFFSET FATBUF              ;   Read Boot Record
  127.           MOV     CX,1
  128.           MOV     DX,0
  129.           INT     25H
  130.           POPF
  131.           MOV     AX,FATBUF[11]                 ;   Read Sector Size and Save
  132.           MOV     SECSIZE,AX
  133.           MOV     AL,BYTE PTR FATBUF[13]        ;   Read Sectors/Cluster and Save
  134.           XOR     AH,AH
  135.           MOV     CLSTSEC,AX
  136.           MOV     BX,FATBUF[22]                 ;   Read Sectors/FAT and Save
  137.           MOV     FATSEC,BX
  138.           MOV     AH,36H                        ;   Get Total Data Clusters
  139.           MOV     DL,DRIVE
  140.           INC     DL
  141.           INT     21H
  142.           ADD     DX,2
  143.           MOV     CLSTTOT,DX                    ;     and Save
  144.           MOV     FATSIZE,3
  145.           MOV     EOF,0FF8H
  146.           CMP     DX,4081                       ;   If Necessary, Adjust FAT Size
  147.           JLE     FAT_OK
  148.           MOV     FATSIZE,4
  149.           MOV     EOF,0FFF8H
  150. FAT_OK:   MOV     AL,DRIVE                      ;   Read FAT
  151.           MOV     CX,FATSEC
  152.           MOV     DX,1
  153.           MOV     BX,OFFSET FATBUF
  154.           INT     25H
  155.           POPF
  156.           POP     SI                            ;   Restore Parameter Pointer
  157. DRV_OK:   MOV     BX,CLUST                      ; Get Cluster Number
  158.           MOV     AX,BX                         ; Convert Cluster No. to ASCII
  159.           MOV     DI,OFFSET CLSTMSG[13]
  160.           CALL    DEC5OUT
  161.           CALL    STRIP0                        ; Strip Off Leading Zeroes
  162.           MOV     AH,9                          ; Output Cluster Message
  163.           MOV     DX,OFFSET CLSTMSG
  164.           INT     21H
  165.           CMP     BX,CLSTTOT                    ; If Invalid, Say So
  166.           JAE     CLST_BAD
  167.           CMP     BX,2
  168.           JAE     CLST_OK
  169. CLST_BAD: MOV     DX,OFFSET INVALID
  170.           JMP     SHORT ERROUT
  171. CLST_OK:  CALL    NEXTCLST                      ; Get Next Cluster Number
  172.           MOV     AX,EOF                        ; Get EOF Value
  173.           CMP     FLAG,0                        ; If /U, Unmark
  174.           JE      UNMARK
  175.           OR      BX,BX                         ; Else Mark
  176.           JZ      IS_FREE
  177.           CMP     BX,AX                         ; If Reserved,
  178.           JB      NOTINUSE
  179. IN_USE:   MOV     DX,OFFSET INUSEMSG
  180.           JMP     SHORT ERROUT                  ; Output Error Message
  181. NOTINUSE: DEC     AX
  182.           CMP     BX,AX
  183.           JNE     NOT_BAD
  184.           MOV     DX,OFFSET BADMSG
  185.           JMP     SHORT ERROUT
  186. NOT_BAD:  SUB     AX,7
  187.           CMP     BX,AX
  188.           JB      IN_USE
  189.           MOV     DX,OFFSET RESVMSG
  190.           JMP     SHORT ERROUT
  191. IS_FREE:  MOV     BX,CLUST                      ; Get Cluster Number
  192.           MOV     AX,EOF                        ; New Value = Bad Cluster
  193.           DEC     AX
  194.           MOV     DX,OFFSET MARKMSG
  195.           JMP     WRT_FAT
  196. UNMARK:   DEC     AX
  197.           CMP     BX,AX                         ; If Not Bad,
  198.           JE      IS_BAD
  199.           MOV     DX,OFFSET NOTBAD
  200. ERROUT:   MOV     AH,9                          ; Output Error Message
  201.           INT     21H
  202.           JMP     STRIP
  203. IS_BAD:   MOV     BX,CLUST                      ; Get Cluster Number
  204.           XOR     AX,AX                         ; New Value = Good Cluster
  205.           MOV     DX,OFFSET UNMRKMSG
  206. WRT_FAT:  PUSH    DX
  207.           CALL    SETCLST
  208.           PUSH    SI                            ; Save Parameter Pointer
  209.           MOV     AL,DRIVE                      ; Write FAT #1
  210.           MOV     CX,FATSEC
  211.           MOV     DX,1
  212.           MOV     BX,OFFSET FATBUF
  213.           INT     26H
  214.           POPF
  215.           MOV     AL,DRIVE                      ; Write FAT #2
  216.           MOV     CX,FATSEC
  217.           MOV     DX,CX
  218.           INC     DX
  219.           MOV     BX,OFFSET FATBUF
  220.           INT     26H
  221.           POPF
  222.           POP     SI                            ; Restore Parameter Pointer
  223.           MOV     AH,9                          ; Output UnMarked Message
  224.           POP     DX
  225.           INT     21H
  226.           JMP     STRIP
  227.  
  228. NEXTCLST: CMP     FATSIZE,3                     ; If FAT Size = 16 Bits,
  229.           JE      NEXT_12
  230.           SHL     BX,1                          ;   Simply Read Next Cluster #
  231.           MOV     BX,FATBUF[BX]
  232.           RET                                   ;   Done
  233. NEXT_12:  PUSH    CX                            ; Save Registers
  234.           MOV     CX,BX                         ; Word # = Cluster # * 1.5
  235.           SHL     CX,1
  236.           ADD     BX,CX
  237.           SHR     BX,1
  238.           MOV     BX,FATBUF[BX]
  239.           JNC     NEXT_OK                       ; If Odd, Use 12 MSB's
  240.           MOV     CL,4
  241.           SHR     BX,CL
  242. NEXT_OK:  AND     BX,0FFFH                      ; Else Use 12 LSB's
  243.           POP     CX                            ; Restore Registers
  244.           RET                                   ; Done
  245.  
  246. SETCLST:  PUSH    AX                            ; Save Registers
  247.           PUSH    BX
  248.           CMP     FATSIZE,3                     ; If FAT Size = 16 Bits,
  249.           JE      SETC_12
  250.           SHL     BX,1                          ;   Simply Read Next Cluster #
  251.           MOV     FATBUF[BX],AX
  252.           JMP     SHORT SET_DONE                ;   Done
  253. SETC_12:  PUSH    CX                            ; Save Registers
  254.           MOV     CX,BX                         ; Word # = Cluster # * 1.5
  255.           SHL     CX,1
  256.           ADD     BX,CX
  257.           SHR     BX,1
  258.           MOV     CX,0F000H
  259.           JNC     SETC_OK                       ; If Odd, Use 12 MSB's
  260.           MOV     CL,4
  261.           SHL     AX,CL
  262.           MOV     CX,0FH
  263. SETC_OK:  AND     FATBUF[BX],CX
  264.           OR      FATBUF[BX],AX
  265.           POP     CX
  266. SET_DONE: POP     BX
  267.           POP     AX
  268.           RET                                   ; Done
  269.  
  270. GET_WORD: PUSH    BX                            ; Save Register
  271.           XOR     DX,DX                         ; Value = 0
  272. GET_WRD1: LODSB                                 ; Read Character
  273.           CMP     AL,'0'                        ; If Not Numeric, Done
  274.           JB      GET_WRD2
  275.           CMP     AL,'9'
  276.           JA      GET_WRD2
  277.           SUB     AL,'0'                        ; Convert to BCD
  278.           CBW
  279.           MOV     BX,AX                         ; Value = Value*10+BCD
  280.           MOV     AX,10
  281.           MUL     DX
  282.           ADD     AX,BX
  283.           MOV     DX,AX
  284.           JMP     GET_WRD1                      ; Repeat
  285. GET_WRD2: DEC     SI
  286.           POP     BX                            ; Restore Register
  287.           RET                                   ; Done
  288.  
  289. STRIP0:   CMP     BYTE PTR [DI],'0'             ; If Character != '0', Done
  290.           JNE     STRIP1
  291.           CMP     BYTE PTR [DI+1],'0'           ; If Next Character != Digit,
  292.           JL      STRIP1                        ;   Done
  293.           CMP     BYTE PTR [DI+1],'9'
  294.           JG      STRIP1
  295.           MOV     BYTE PTR [DI],' '             ; Change '0' to ' '
  296.           INC     DI                            ; Point to Next Character
  297.           JMP     SHORT STRIP0                  ; Repeat
  298. STRIP1:   RET                                   ; Done
  299.  
  300. DEC2OUT:  PUSH    AX                            ; Save Registers
  301.           PUSH    BX
  302.           XOR     AH,AH                         ; Clear AH
  303.           MOV     BL,10                         ; AH=AX%10,AL=AX/10
  304.           DIV     BL
  305.           ADD     AX,'00'                       ; Convert to ASCII
  306.           SUB     DI,2
  307.           MOV     [DI],AX                       ; Store in String
  308.           POP     BX                            ; Restore Registers
  309.           POP     AX
  310.           RET                                   ; Done
  311.  
  312. DEC4OUT:  PUSH    AX                            ; Save Registers
  313.           PUSH    BX
  314.           MOV     BL,100                        ; AH=AX%100,AL=AX/100
  315.           DIV     BL
  316.           XCHG    AH,AL                         ; Convert 2 LSD's
  317.           CALL    DEC2OUT
  318.           XCHG    AH,AL                         ; Convert 2 MSD's
  319.           CALL    DEC2OUT
  320.           POP     BX                            ; Restore Registers
  321.           POP     AX
  322.           RET                                   ; Done
  323.  
  324. DEC5OUT:  PUSH    AX                            ; Save Registers
  325.           PUSH    BX
  326.           PUSH    DX                            ; DX=AX%10000,AX=AX/10000
  327.           MOV     BX,10000
  328.           XOR     DX,DX
  329.           DIV     BX
  330.           XCHG    DX,AX                         ; Convert 4 LSD's
  331.           CALL    DEC4OUT
  332.           XCHG    DX,AX                         ; Convert MSD
  333.           ADD     AL,'0'
  334.           SUB     DI,1
  335.           MOV     [DI],AL
  336.           POP     DX                            ; Restore Registers
  337.           POP     BX
  338.           POP     AX
  339.           RET                                   ; Done
  340.  
  341. FATBUF    LABEL   WORD
  342.  
  343. CODE      ENDS
  344.  
  345.           END     MARK
  346.